// Service Worker for Asset Management System PWA
const CACHE_NAME = 'asset-management-v1.0.0';
const urlsToCache = [
  '/',
  '/static/css/bootstrap.min.css',
  '/static/js/bootstrap.bundle.min.js',
  '/static/js/jquery-3.6.0.min.js',
  '/static/css/fontawesome.min.css',
  '/static/webfonts/fa-solid-900.woff2',
  '/static/images/icon-192x192.png',
  '/static/images/icon-512x512.png',
  '/assets/mobile/scan/',
  '/assets/assets/',
  '/assets/dashboard/',
];

// 安装事件
self.addEventListener('install', function(event) {
  console.log('Service Worker 安装中...');
  
  event.waitUntil(
    caches.open(CACHE_NAME)
      .then(function(cache) {
        console.log('缓存已打开');
        return cache.addAll(urlsToCache);
      })
      .catch(function(error) {
        console.error('缓存安装失败:', error);
      })
  );
});

// 激活事件
self.addEventListener('activate', function(event) {
  console.log('Service Worker 激活中...');
  
  event.waitUntil(
    caches.keys().then(function(cacheNames) {
      return Promise.all(
        cacheNames.map(function(cacheName) {
          if (cacheName !== CACHE_NAME) {
            console.log('删除旧缓存:', cacheName);
            return caches.delete(cacheName);
          }
        })
      );
    })
  );
});

// 拦截网络请求
self.addEventListener('fetch', function(event) {
  // 只处理GET请求
  if (event.request.method !== 'GET') {
    return;
  }
  
  // 对于API请求，优先使用网络
  if (event.request.url.includes('/api/')) {
    event.respondWith(
      fetch(event.request)
        .then(function(response) {
          // 如果网络请求成功，缓存响应
          if (response.status === 200) {
            const responseClone = response.clone();
            caches.open(CACHE_NAME).then(function(cache) {
              cache.put(event.request, responseClone);
            });
          }
          return response;
        })
        .catch(function() {
          // 网络失败时，尝试从缓存获取
          return caches.match(event.request);
        })
    );
    return;
  }
  
  // 对于其他请求，使用缓存优先策略
  event.respondWith(
    caches.match(event.request)
      .then(function(response) {
        // 如果缓存中有，直接返回
        if (response) {
          return response;
        }
        
        // 否则发起网络请求
        return fetch(event.request)
          .then(function(response) {
            // 检查响应是否有效
            if (!response || response.status !== 200 || response.type !== 'basic') {
              return response;
            }
            
            // 克隆响应用于缓存
            const responseToCache = response.clone();
            
            caches.open(CACHE_NAME)
              .then(function(cache) {
                cache.put(event.request, responseToCache);
              });
            
            return response;
          })
          .catch(function() {
            // 网络请求失败，返回离线页面
            if (event.request.destination === 'document') {
              return caches.match('/offline.html');
            }
          });
      })
  );
});

// 后台同步
self.addEventListener('sync', function(event) {
  console.log('后台同步事件:', event.tag);
  
  if (event.tag === 'background-sync') {
    event.waitUntil(doBackgroundSync());
  }
});

// 推送通知
self.addEventListener('push', function(event) {
  console.log('收到推送消息:', event);
  
  const options = {
    body: event.data ? event.data.text() : '您有新的系统通知',
    icon: '/static/images/icon-192x192.png',
    badge: '/static/images/badge-72x72.png',
    vibrate: [100, 50, 100],
    data: {
      dateOfArrival: Date.now(),
      primaryKey: 1
    },
    actions: [
      {
        action: 'explore',
        title: '查看详情',
        icon: '/static/images/checkmark.png'
      },
      {
        action: 'close',
        title: '关闭',
        icon: '/static/images/xmark.png'
      }
    ]
  };
  
  event.waitUntil(
    self.registration.showNotification('资产管理系统', options)
  );
});

// 通知点击事件
self.addEventListener('notificationclick', function(event) {
  console.log('通知被点击:', event);
  
  event.notification.close();
  
  if (event.action === 'explore') {
    // 打开应用
    event.waitUntil(
      clients.openWindow('/')
    );
  } else if (event.action === 'close') {
    // 关闭通知
    event.notification.close();
  } else {
    // 默认行为：打开应用
    event.waitUntil(
      clients.openWindow('/')
    );
  }
});

// 后台同步函数
async function doBackgroundSync() {
  try {
    // 同步离线数据
    const offlineData = await getOfflineData();
    
    if (offlineData.length > 0) {
      for (const data of offlineData) {
        await syncDataToServer(data);
      }
      
      // 清除已同步的离线数据
      await clearOfflineData();
    }
    
    console.log('后台同步完成');
  } catch (error) {
    console.error('后台同步失败:', error);
  }
}

// 获取离线数据
async function getOfflineData() {
  return new Promise((resolve) => {
    // 这里应该从IndexedDB或其他存储中获取离线数据
    // 暂时返回空数组
    resolve([]);
  });
}

// 同步数据到服务器
async function syncDataToServer(data) {
  try {
    const response = await fetch('/api/sync/', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(data)
    });
    
    if (!response.ok) {
      throw new Error('同步失败');
    }
    
    return await response.json();
  } catch (error) {
    console.error('数据同步失败:', error);
    throw error;
  }
}

// 清除离线数据
async function clearOfflineData() {
  // 清除已同步的离线数据
  console.log('清除离线数据');
}